• Anna Jurkiewicz 116679

• Dominika Kaczmarska 116977

studia niestacjonarne sobotnio - niedzielne

Projekt z przedmiotu "Podstawy Aproksymacji - od analizy Fouriera po deep learning"

Wstęp

Słuchając muzyki, często ograniczamy się do słuchania sprawdzonej playlisty. Ograniczając się do lubianej playlisty, ciężko śledzić nowości, a przesłuchane piosenki X razy zaczynają się nam nudzić.

A co gdyby móc z playlisty zawierającej nowości wybrać tylko te, które są zgodne z naszym gustem? Oszczędzimy czas spędzony na omijaniu piosenek, które po przesłuchania kawałka nie do końca są w naszym guście, a do tego będziemy mogli ciągle znajdować piosenki, które będą miłe dla naszego ucha.

Zbiór danych

Aby stworzyć model, który będzie wybierał piosenki, które nam się spodobają, potrzebujemy dwa zbiory:

• utworów, które nam się podobają
• utworów, które zupełnie nie są w naszym guście

W celu pozyskania danych korzystamy z danych, które możemy pobrać z naszego konta na Spotify. Oprócz informacji takich jak tytuł i wykonawca, Spotify udostępnia wiele parametrów piosenek, np. taneczność, głośność, muzykalność.

Jako piosenki, które nam się spodobają, najłatwiej wziąć zbiór piosenek 'zaserduszkowanych'. Jeśli chodzi o zbiór utworów, które nie są w naszym guście postanowiłyśmy kierować się dwoma gatunkami: Disco i Heavy Metal. Gatunki się bardzo różnią od siebie, aczkolwiek są tak samo nie lubiane przez nas.

Spotify umożliwia pobieranie tych playlist poprzez stworzenie aplikacji nadającej dostęp do konta, zapewnionej przez "Spotify for Dewelopers". Niestety Web API Wrappers w Julii jest jeszcze w fazie testów, więc w celu pobrania danych skorzystałyśmy z Pythona. Wygenerowane dane wgrywamy do Julii jako CSV.

using DataFrames
using CSV
using StatsBase

ulubione = CSV.read("C:\\Users\\domi\\Desktop\\studia_sgh\\sem2\\ulubione.csv", DataFrame);
disco = CSV.read("C:\\Users\\domi\\Desktop\\studia_sgh\\sem2\\disco.csv", DataFrame);
metal = CSV.read("C:\\Users\\domi\\Desktop\\studia_sgh\\sem2\\metal.csv", DataFrame);

Zobaczmy jak wygląda struktura takiego zbioru

describe(ulubione)

19 rows × 7 columns (omitted printing of 2 columns)

	variable	mean	min	median	max
	Symbol	Union…	Any	Union…	Any
1	Column1	0.0	0	0.0	0
2	uri		spotify:track:018Idkvf82hi44UZmIXiGB		spotify:track:7yq4Qj7cqayVTp3FF9CWbm
3	name		(I Just) Died In Your Arms		Świt (feat. Daria Zawiałow, KRÓL & Igo)
4	artist		24kGoldn		sanah
5	album		13 Reasons Why (Season 2)		Świt (feat. Daria Zawiałow, KRÓL & Igo)
6	popularity	43.8392	0	52.0	89
7	danceability	0.622018	0.188	0.646	0.953
8	energy	0.572216	0.0549	0.588	0.971
9	key	5.36181	0	6.0	11
10	loudness	-8.07771	-20.822	-7.418	-2.588
11	mode	0.537688	0	1.0	1
12	speechiness	0.0678415	0.0237	0.0433	0.639
13	acousticness	0.356993	3.76e-5	0.2755	0.989
14	instrumentalness	0.024199	0.0	2.22e-6	0.862
15	liveness	0.179497	0.0363	0.117	0.987
16	valence	0.494642	0.0393	0.4825	0.973
17	tempo	119.123	53.863	119.557	206.042
18	duration_ms	2.07947e5	99227	2.03214e5	442733
19	time_signature	3.9397	1	4.0	5

Parametry utworów, których będziemy używać do analizy, to:

• danceability - taneczność, opisuje jak bardzo piosenka nadaje się do tańczenia
• energy - energia, opisuje miare percepcji bazującej na intensywności i aktywności
• speechiness - wypowiedziane słowa- wykrywa obecność w utworze wypowiedzianych słów
• acousticness - akustyczność - miara, określająca czy piosenka jest akustyczna
• instrumentalness - instrumentalność, prognozuje, czy utwór nie zawiera wokali
• tempo - tempo, szacowane tempo utworu w uderzeniach na mnute (BPM)
• loudness - głośność, ogólna głosność ścieżki w decybelach
• liveness - żywnotność, wykrywa obecność pbliczności na nagraniu
• valence - wartościowość, opisuje nastrój utworu

Przygotujmy tabele zawierające te parametry oraz ustalmy ich typy na Float64

ulubione[!, :danceability] = convert(Vector{Float64}, ulubione[!, :danceability]);
ulubione[!, :energy] = convert(Vector{Float64}, ulubione[!, :energy]);
ulubione[!, :speechiness] = convert(Vector{Float64}, ulubione[!, :speechiness]);
ulubione[!, :acousticness] = convert(Vector{Float64}, ulubione[!, :acousticness]);
ulubione[!, :instrumentalness] = convert(Vector{Float64}, ulubione[!, :instrumentalness]);
ulubione[!, :tempo] = convert(Vector{Float64}, ulubione[!, :tempo]);
ulubione[!, :loudness] = convert(Vector{Float64}, ulubione[!, :loudness]);
ulubione[!, :liveness] = convert(Vector{Float64}, ulubione[!, :liveness]);
ulubione[!, :valence] = convert(Vector{Float64}, ulubione[!, :valence]);

ulubione = select(ulubione, :danceability, :energy, :speechiness, :acousticness, :instrumentalness, :tempo, :loudness, :liveness, :valence);

metal[!, :danceability] = convert(Vector{Float64}, metal[!, :danceability]);
metal[!, :energy] = convert(Vector{Float64}, metal[!, :energy]);
metal[!, :speechiness] = convert(Vector{Float64}, metal[!, :speechiness]);
metal[!, :acousticness] = convert(Vector{Float64}, metal[!, :acousticness]);
metal[!, :instrumentalness] = convert(Vector{Float64}, metal[!, :instrumentalness]);
metal[!, :tempo] = convert(Vector{Float64}, metal[!, :tempo]);
metal[!, :loudness] = convert(Vector{Float64}, metal[!, :loudness]);
metal[!, :liveness] = convert(Vector{Float64}, metal[!, :liveness]);
metal[!, :valence] = convert(Vector{Float64}, metal[!, :valence]);

metal = select(metal, :danceability, :energy, :speechiness, :acousticness, :instrumentalness, :tempo, :loudness, :liveness, :valence);

disco[!, :danceability] = convert(Vector{Float64}, disco[!, :danceability]);
disco[!, :energy] = convert(Vector{Float64}, disco[!, :energy]);
disco[!, :speechiness] = convert(Vector{Float64}, disco[!, :speechiness]);
disco[!, :acousticness] = convert(Vector{Float64}, disco[!, :acousticness]);
disco[!, :instrumentalness] = convert(Vector{Float64}, disco[!, :instrumentalness]);
disco[!, :tempo] = convert(Vector{Float64}, disco[!, :tempo]);
disco[!, :loudness] = convert(Vector{Float64}, disco[!, :loudness]);
disco[!, :liveness] = convert(Vector{Float64}, disco[!, :liveness]);
disco[!, :valence] = convert(Vector{Float64}, disco[!, :valence]);

disco = select(disco, :danceability, :energy, :speechiness, :acousticness, :instrumentalness, :tempo, :loudness, :liveness, :valence);

Ze względu na to, że parametry mają różne zbiory wartości, wszystkie kolumny poddamy procedurze standaryzacji

ulubione = mapcols(zscore, ulubione);
disco = mapcols(zscore, disco);
metal = mapcols(zscore, metal);

Stwórzmy dwa zbiory lubiane i nie_lubiane, w których dodamy kolumnę like z wartościami:

• 1 - utwór jest w naszym guście
• 0 - utwór nie jest w naszym guście

lubiane = ulubione;

insertcols!(lubiane,
    1, 
    :like => 1.0);

first(lubiane, 5)

5 rows × 10 columns (omitted printing of 3 columns)

	like	danceability	energy	speechiness	acousticness	instrumentalness	tempo
	Float64	Float64	Float64	Float64	Float64	Float64	Float64
1	1.0	1.02762	0.123739	-0.189669	-0.937936	-0.22154	0.814404
2	1.0	-0.124042	1.69785	-0.416866	-0.937936	-0.221341	0.399336
3	1.0	0.415346	0.728429	-0.474006	-1.16369	-0.221492	0.294777
4	1.0	-0.0875964	1.15075	-0.518901	-0.978988	-0.219618	0.1057
5	1.0	0.962022	-0.591331	-0.0862733	1.20531	-0.22154	-1.35484

nrow(lubiane)

398

Zbiór lubianych zawiera 398 obserwacji.

nie_lubiane = vcat(disco, metal);

insertcols!(nie_lubiane,
    1, 
    :like => 0.0);

first(nie_lubiane, 5)

5 rows × 10 columns (omitted printing of 3 columns)

	like	danceability	energy	speechiness	acousticness	instrumentalness	tempo
	Float64	Float64	Float64	Float64	Float64	Float64	Float64
1	0.0	0.140936	0.780537	1.24708	-0.0620549	-0.132255	0.307438
2	0.0	-1.50098	0.999032	-0.311232	-0.650521	-0.1257	2.5419
3	0.0	-0.146932	0.0490516	-0.774048	-0.670619	-0.132255	-0.166407
4	0.0	1.00454	0.391045	-0.00843213	-0.30221	-0.131497	-0.00902013
5	0.0	1.26042	0.457543	-0.746968	-0.615605	-0.132255	-0.330933

nrow(nie_lubiane)

656

Zbiór nielubianych piosenek zawiera 656 obserwacji.

W celu sprawdzenia, czy te parametry będą przyjmować różne wartości dla lubianych i nielubianych wartości, dla obu zbiorów tworzymy cornetploty oraz patrzymy czy rozkłady dla parametrów są od siebie różne. Ze względu na to, że pokazując wykresy dla wszystkich parametrów tracimy na czytelności, podzielimy parametry na dwie grupy.

using StatsPlots

1.1) Cornerplot zbioru lubiane dla parametrów: acousticness, speechiness, energy, danceability

@df lubiane cornerplot(cols(2:5))

1.2) Cornerplot zbioru nie_lubiane dla parametrów: acousticness, speechiness, energy, danceability

@df nie_lubiane cornerplot(cols(2:5))

2.1) Cornerplot zbioru lubiane dla parametrów: instrumentalness, tempo, loudness, liveness, valence

@df lubiane cornerplot(cols(6:10))

2.2) Cornerplot zbioru nie_lubiane dla parametrów: instrumentalness, tempo, loudness, liveness, valence

@df nie_lubiane cornerplot(cols(6:10))

Możemy zauważyć, dla każdego zbioru parametry mają inne charakterystyki. W celu potwierdzenia porównujemy podstawowe statystyki obu zbiorów(min,max,mediana,średnia).

describe(lubiane)

10 rows × 7 columns

	variable	mean	min	median	max	nmissing	eltype
	Symbol	Float64	Float64	Float64	Float64	Int64	DataType
1	like	1.0	1.0	1.0	1.0	0	Float64
2	danceability	-1.04746e-15	-3.16356	0.174808	2.41254	0	Float64
3	energy	5.77428e-17	-2.48267	0.0757478	1.91381	0	Float64
4	speechiness	1.69323e-16	-0.600529	-0.333878	7.77041	0	Float64
5	acousticness	2.58029e-17	-1.1723	-0.267636	2.07562	0	Float64
6	instrumentalness	-1.95265e-18	-0.22154	-0.22152	7.67003	0	Float64
7	tempo	-1.89617e-16	-2.4309	0.016153	3.23765	0	Float64
8	loudness	3.78257e-16	-4.21956	0.218427	1.81761	0	Float64
9	liveness	-2.2853e-16	-0.940403	-0.410432	5.30301	0	Float64
10	valence	-2.30413e-16	-1.95161	-0.0520429	2.05025	0	Float64

describe(nie_lubiane)

10 rows × 7 columns

	variable	mean	min	median	max	nmissing	eltype
	Symbol	Float64	Float64	Float64	Float64	Int64	DataType
1	like	0.0	0.0	0.0	0.0	0	Float64
2	danceability	-2.09013e-16	-3.32414	0.0688514	3.52625	0	Float64
3	energy	-5.18217e-16	-4.60585	0.291297	1.33153	0	Float64
4	speechiness	-3.70469e-16	-0.978229	-0.37681	5.59131	0	Float64
5	acousticness	-6.01653e-17	-0.732004	-0.371886	6.42193	0	Float64
6	instrumentalness	-3.15635e-17	-0.494988	-0.132255	12.7843	0	Float64
7	tempo	-1.26796e-15	-4.66244	-0.0134722	3.36653	0	Float64
8	loudness	5.7542e-17	-6.86931	0.188179	1.93738	0	Float64
9	liveness	-1.94966e-16	-1.23768	-0.344738	5.05232	0	Float64
10	valence	-4.93846e-16	-4.39903	0.190455	2.5148	0	Float64

Możemu zauważyć w obu grupach statystyki różnią się od siebie.

Model

Aby zbudować model, łączymy nasze zbiory w jeden data frame.

df = vcat(nie_lubiane, lubiane);

Ze względu na to, że nasz zbiór ma mniejszą liczbę 'jedynek' (utwór, które lubimy) od 'zer' (utwór, których nie lubimy) dzieląc zbiór na zbiór uczący i testowy użyjemy funkcji stratifiedobs. Dzięki niej mamy gwarancję, że proporcja jedynek do zer w obu zbiór będzie taka sama. Zbiory dzielimy w proporcji 70:30 (uczący:testowy)

using MLDataUtils
using Flux
using Statistics
using LinearAlgebra
using Metrics

using Flux: crossentropy, onecold, onehotbatch, params, train!

(X_train,y_train), (X_test,y_test) = stratifiedobs((df[:, 2:end], df[!, :like]), p = 0.7);

X_train = Matrix(X_train)';
X_test = Matrix(X_test)';

y_train = onehotbatch(y_train, 0:1)

2×738 OneHotMatrix(::Vector{UInt32}) with eltype Bool:
 ⋅  1  ⋅  1  1  1  1  1  1  1  1  1  1  …  1  1  1  1  1  1  1  1  1  1  1  1
 1  ⋅  1  ⋅  ⋅  ⋅  ⋅  ⋅  ⋅  ⋅  ⋅  ⋅  ⋅     ⋅  ⋅  ⋅  ⋅  ⋅  ⋅  ⋅  ⋅  ⋅  ⋅  ⋅  ⋅

y_test = onehotbatch(y_test, 0:1)

2×316 OneHotMatrix(::Vector{UInt32}) with eltype Bool:
 1  1  1  ⋅  1  1  1  1  ⋅  1  ⋅  1  1  …  1  ⋅  1  ⋅  1  1  1  ⋅  1  1  ⋅  ⋅
 ⋅  ⋅  ⋅  1  ⋅  ⋅  ⋅  ⋅  1  ⋅  1  ⋅  ⋅     ⋅  1  ⋅  1  ⋅  ⋅  ⋅  1  ⋅  ⋅  1  1

Model, którymy się posłużymy to sieć klasyfikacyjna. Jest to odmiana sieci neuronowej, w której sygnały wyjściowe mają chrakter jakościowy.

Struktura obejmue warstwę wejściową, warstawę ukrytą oraz warstwe wyjściową. Za funckje aktywacji dla warstwy wejściowej i ukrytej przyjmujemy funkcje relu6. relu6(x)=min(max(0,x),6).

Warstwa wejściowa zawiera 9 neuronów, warstwa ukryta posiada 4 neurony oraz warstwa wyjściowa 2 neurony. Połączenie(dense) warstwy wejściowej z warstwą ukrytą daje nam 40 parametrów, a połączenie warstwy ukrytej z warstwą wyjściową daje nam 10 parametrów.

Dla warstwy wyjściowej przyjmujemy funckje aktywacji - softmax.

model = Chain(
    Dense(9, 4, relu6),
    Dense(4 ,2),
    softmax
)

Chain(
  Dense(9 => 4, relu6),                 # 40 parameters
  Dense(4 => 2),                        # 10 parameters
  NNlib.softmax,
)                   # Total: 4 arrays, 50 parameters, 456 bytes.

Za funkcje straty przyjmujemy binary_focal_loss.

loss(x, y)= Flux.binary_focal_loss(model(x), y)

loss (generic function with 1 method)

loss(X_train, y_train)

0.7278780151512113

Dla naszej sieci wagi wybierane są z góry losowo.

ps = params(model)

Params([Float32[0.34076843 -0.5061116 … 0.44952604 -0.45178792; 0.28195462 -0.64783144 … 0.09097519 -0.59088284; -0.0049434323 0.20113994 … 0.6676843 0.013157353; -0.18410648 0.17132644 … 0.4602443 -0.21729957], Float32[0.0, 0.0, 0.0, 0.0], Float32[-0.59071755 -0.20811641 0.19414532 0.8807962; 0.62621593 0.96681046 -0.6072341 -0.6091893], Float32[0.0, 0.0]])

Za optymalizator przyjmujemy funkcję NADAM - Nesterovą odmiane ADAMa. Parametry nie wymagają dostrajania.

opt = NADAM()

NADAM(0.001, (0.9, 0.999), 1.0e-8, IdDict{Any, Any}())

Jako że neurony w warstwie wyjściowej przyjmują wartości binarne, do policzenia wartości dokładności możemy użyć średniej

accuracy(x, y) = mean(onecold(model(x)).==onecold(y))

accuracy (generic function with 1 method)

accuracy(X_train, y_train)

0.521680216802168

loss_history = []

Any[]

epochs = 200

200

Przechodzimy do trenowania sieci

for epoch in 1:epochs
    train!(loss, ps, [(X_train, y_train)], opt)
    train_loss = loss(X_train, y_train)
    push!(loss_history, train_loss)
end

Sprawdźmy jak wygląda funkcja straty w modelu podczas jego uczenia

Plots.plot(1:epochs, loss_history,
    xlabel = "Epchos",
    ylabel = "Loss",
    title = "Learning curve",
    legend = false)

Sprawdżmy wartość dokładności na zbiorze uczącym

accuracy(X_train, y_train)

0.573170731707317

Oraz na zbiorze testowym

accuracy(X_test, y_test)

0.5791139240506329

Model ten nie jest zadowalający, więc stworzymy model w którym budowa warst będzie taka sama. Nastomiast dla warstwy wyjściowej przyjmujemy sigmoidalną funkcje aktywacji (znormalizowana funkcja wykładnicza). Za funkcje straty przyjmujemy binarną entropie krzyżową.

model2 = Chain(
    Dense(9, 4, relu6),
    Dense(4 ,2),
    softmax
)

Chain(
  Dense(9 => 4, relu6),                 # 40 parameters
  Dense(4 => 2),                        # 10 parameters
  NNlib.softmax,
)                   # Total: 4 arrays, 50 parameters, 456 bytes.

loss2(x, y)= Flux.mse(model2(x), y)
loss2(X_train, y_train)

0.28541474156499314

ps2 = params(model2)
opt2 = NADAM()
accuracy2(x, y) = mean(onecold(model2(x)).==onecold(y));

accuracy2(X_train, y_train)

0.5663956639566395

loss_history2 = []
epochs = 400

for epoch in 1:epochs
    train!(loss2, ps2, [(X_train, y_train)], opt2)
    train_loss = loss2(X_train, y_train)
    push!(loss_history2, train_loss)
end

Plots.plot(1:epochs, loss_history2,
    xlabel = "Epchos",
    ylabel = "Loss",
    title = "Learning curve",
    legend = false)

accuracy2(X_train, y_train)

0.6341463414634146

accuracy2(X_test, y_test)

0.6234177215189873

Obserwujemy, że po zmienie funkcji straty uzyskujemy lepsze wyniki. Kolejną modyfikacją będzie zmiana budowy naszej sieci. Wprowadzamy dodatkową warstwe ukrytą.

model3 = Chain(
    Dense(9, 6, relu6),
    Dense(6, 4),
    Dense(4, 2),
    softmax
)

Chain(
  Dense(9 => 6, relu6),                 # 60 parameters
  Dense(6 => 4),                        # 28 parameters
  Dense(4 => 2),                        # 10 parameters
  NNlib.softmax,
)                   # Total: 6 arrays, 98 parameters, 776 bytes.

loss3(x, y)= Flux.mse(model3(x), y)
loss3(X_train, y_train)

0.28679386502302057

ps3 = params(model3)
opt3 = NADAM(0.01)
accuracy3(x, y) = mean(onecold(model3(x)).==onecold(y));

accuracy3(X_train, y_train)

0.5094850948509485

loss_history3 = []
epochs = 300

for epoch in 1:epochs
    train!(loss3, ps3, [(X_train, y_train)], opt3)
    train_loss = loss3(X_train, y_train)
    push!(loss_history3, train_loss)
end

Plots.plot(1:epochs, loss_history3)

accuracy3(X_train, y_train)

0.9065040650406504

accuracy3(X_test, y_test)

0.8259493670886076

Ten model posiada już zadowolające nas wyniki, użyjemy go do sprawdzenia, które piosenki w danej playliście mogą nam się spodobać. Wgrajmy dane o playliście "New music Friday Polska" oraz zastosujmy przekształcenia takie, jak na zbiorach uczących.

new_music_polska_raw = CSV.read("C:\\Users\\domi\\Desktop\\studia_sgh\\sem2\\new_music_polska.csv", DataFrame);

new_music_polska = new_music_polska_raw;

new_music_polska[!, :danceability] = convert(Vector{Float64}, new_music_polska[!, :danceability]);
new_music_polska[!, :energy] = convert(Vector{Float64}, new_music_polska[!, :energy]);
new_music_polska[!, :speechiness] = convert(Vector{Float64}, new_music_polska[!, :speechiness]);
new_music_polska[!, :acousticness] = convert(Vector{Float64}, new_music_polska[!, :acousticness]);
new_music_polska[!, :instrumentalness] = convert(Vector{Float64}, new_music_polska[!, :instrumentalness]);
new_music_polska[!, :tempo] = convert(Vector{Float64}, new_music_polska[!, :tempo]);
new_music_polska[!, :loudness] = convert(Vector{Float64}, new_music_polska[!, :loudness]);
new_music_polska[!, :liveness] = convert(Vector{Float64}, new_music_polska[!, :liveness]);
new_music_polska[!, :valence] = convert(Vector{Float64}, new_music_polska[!, :valence]);

new_music_polska = select(new_music_polska, :danceability, :energy, :speechiness, :acousticness, :instrumentalness, :tempo, :loudness, :liveness, :valence);

new_music_polska = mapcols(zscore, new_music_polska);

new_music_polska = Matrix(new_music_polska)' ;

likes = model3(new_music_polska)

2×100 Matrix{Float64}:
 0.853952  0.0290526  0.0993028  …  0.95541    0.981561   0.99049
 0.146048  0.970947   0.900697      0.0445903  0.0184391  0.00950969

likes = onecold(likes).-1

100-element Vector{Int64}:
 0
 1
 1
 1
 0
 1
 1
 1
 0
 0
 1
 0
 0
 ⋮
 1
 0
 0
 0
 0
 1
 0
 0
 0
 0
 0
 0

Powstały wektor dodajemy do pierwotnego zbioru z tytułami, filtrujemy po jedynkach. Za pomocą modelu dostajemy 38 utworów, które powinny nam się spodobać

likes_new_polska = hcat(new_music_polska_raw, likes);

select(filter(:x1 => ==(1), likes_new_polska), :name, :artist)

38 rows × 2 columns

	name	artist
	String	String31
1	BREAK MY SOUL	Beyoncé
2	Easy Rider	White 2115
3	Sharks	Imagine Dragons
4	Przypadki	Ania Leon
5	The Drop	Dimitri Vegas
6	KFC	Otsochodzi
7	To Też O Tobie	Igo
8	Overdosed	TYNSKY
9	#fejm	bryska
10	Not EAZY Life	Kukon
11	Disaster	Conan Gray
12	Iskry	Bovska
13	Psychic	Chris Brown
14	Cracker Island (feat. Thundercat)	Gorillaz
15	Jestem	Catz 'n Dogz
16	From The D 2 The LBC (with Snoop Dogg)	Eminem
17	deep in the woods	Hayley Kiyoko
18	hollaback bitch (with Shygirl & Channel Tres)	Mura Masa
19	Zielona bluza	Wiktoria Zwolińska
20	Nie dotykaj	DJ BRK
21	Her Body Is Bible	FLETCHER
22	Dwie Twarze	Gverilla
23	Bez Limitu	Oska030
24	Bad Ass Bitches	Wiz Khalifa
25	pogo	bbno$
26	AUTOBUS	Kaen
27	Lost Me	Giveon
28	Blue Eye	La Giang
29	SHOWING OFF HER BODY (with Davido)	DaBaby
30	Bad For Me (feat. Teddy Swims)	Meghan Trainor
⋮	⋮	⋮

Powstała playlista została przez nas przesłuchana i utwory przypadły do gustu - jednak może mieć na to wpływ fakt, że lubimy muzykę radiową.

Sprawdźmy jeszcze jak nasz model oceni nasze zainteresowanie gatunkiem, którego też nie jesteśmy wielkim fanem - RAP (aczkolwiek już prędzej go posłuchamy, niż heavy metal lub disco polo)

rap = CSV.read("C:\\Users\\domi\\Desktop\\studia_sgh\\sem2\\rap.csv", DataFrame);

rap[!, :danceability] = convert(Vector{Float64}, rap[!, :danceability]);
rap[!, :energy] = convert(Vector{Float64}, rap[!, :energy]);
rap[!, :speechiness] = convert(Vector{Float64}, rap[!, :speechiness]);
rap[!, :acousticness] = convert(Vector{Float64}, rap[!, :acousticness]);
rap[!, :instrumentalness] = convert(Vector{Float64}, rap[!, :instrumentalness]);
rap[!, :tempo] = convert(Vector{Float64}, rap[!, :tempo]);
rap[!, :loudness] = convert(Vector{Float64}, rap[!, :loudness]);
rap[!, :liveness] = convert(Vector{Float64}, rap[!, :liveness]);
rap[!, :valence] = convert(Vector{Float64}, rap[!, :valence]);

rap = select(rap, :danceability, :energy, :speechiness, :acousticness, :instrumentalness, :tempo, :loudness, :liveness, :valence);

rap = mapcols(zscore, rap);

rap = Matrix(rap)';

like_rap = model3(rap);

like_rap = onecold(like_rap).-1

46-element Vector{Int64}:
 0
 0
 0
 1
 0
 1
 0
 1
 1
 1
 1
 0
 0
 ⋮
 1
 0
 0
 1
 0
 0
 0
 1
 0
 0
 1
 0

mean(like_rap)

0.2608695652173913

Nasz model twierdzi, że tylko 26% piosenek z wybranej przez nas rapowej playlisty przypadnie nam do gustu - myślimy że ten wynik jest bardzo trafny.

Podsumowanie

W prezentowanym raporcie zmierzyliśmy się z problemem doboru nowych piosenek biorąc pod uwagę nasz gust. Naszym celem było stworzenie modelu, który na podstawie informacji ze Spotify o tym, jakie piosenki lubimy oraz jakich nie, wskaże utwory z konkretnej playlisty które nam się mogą spodobać.

Do tego wykorzystaliśmy sieci klasyfikacyjne. Pierwszy model, który zbudowaliśmy składał się z 1 warstwy wejściowej, 1 warstw ukrytej oraz 1 warstwy wyjściowej. Za funkcje aktywacji na warstwie wejściowej i ukrytej przyjęliśmy funkcje relu6, a za funkcje aktywacji na warstwie wyjściowej softmax. Wykorzystaną funkcją straty była funkcja binary_focal_loss, optymizatorem funkcja NADAM. Dokładność modelu na zbiorze uczącym wyniosła 0.573 a na zbiorze testowym 0.579. Wynik ten nas nie zadowolił dlatego stworzyliśmy kolejny model oparty na sieci o tych samych warstwach.

Model 2 składał się również z 1 warstwy wejściowej, 1 warstw ukrytej oraz 1 warstwy wyjściowej. Za funkcje aktywacji na warstwie wejściowej i ukrytej przyjęliśmy funkcje relu6, za funkcje aktywacji na warstwie wyjściowej softmax, a za optymizator NADAM(). Za funkcje starty przyjęliśmy MSE. Dokładność modelu na zbiorze uczącym wyniosła 0.634, a na zbiorze testowym 0.6234. Zatem po zmianie funkcji starty - uzyskaliśmy lepsze wyniki.

W modelu 3 wprowadziliśmy modyfikacje do struktury naszej sieci i dodaliśmy 1 warstwę ukrytą. Pozostałe funkcje aktywacji oraz straty pozostały bez zmian. W optymizatorze domyślny parametr 0.001 zamieniliśmy na 0.01. Otrzymane wartości dokładności to 0.90 na zbiorze uczącym się oraz 0.82 na zbiorze testowym. Takie wyniki zostały uznane przez nas za satysfakcjonujące.

Następnie model 3 wykorzystaliśmy do tego, aby z playlisty z nowymi utworami - New music friday Polska- zostały wybrane utwory, które mogą nam się spodobać. Model słusznie trafił w nasze gusta.

Kolejnym krokiem było przekonanie się jak nasz model oceni sympatię do gatunku, który raczej nie należy do preferowanych przez nas. Model pokazał, że 26% piosenek z playlisty z muzyką z gatunku rap może nam się spodobać. Jest to jak najbardziej zgodne z naszym gustem oraz muzyką jakiej słuchamy przeważnie.

Podsumowując oceniamy model 3 jako dobry i satysfakcjonujący. Model ten poprawnie wybrał nowe, potencjalnie ulubione piosenki oraz trafnie ocenił zainteresowanie nowym gatunkiem.

Bibliografia

• https://medium.com/@boplantinga/what-do-spotifys-audio-features-tell-us-about-this-year-s-eurovision-song-contest-66ad188e112a
• https://discourse.julialang.org/t/standardize-all-columns-of-dataframe/77772/4
• Leksykon Sieci Neuronowych Ryszard Tadeusiewicz, Maciej Szaleniec, 2015
• https://fluxml.ai/Flux.jl/stable/models/layers/
• https://juliastats.org/StatsBase.jl/stable/transformations/
• https://juliadatascience.io/select
• https://towardsdatascience.com/build-your-first-neural-network-with-flux-jl-in-julia-10ebdfcf2fa3?fbclid=IwAR18tRzk69oYBVMl4jGU1qHHQ8ySG0IaP13LPzB9iyxWAjm7-TNymeNPJfM
• https://github.com/julia4ta/tutorials/tree/master/Series%2005/Tutorial%2005x08
• https://www.analyticsvidhya.com/blog/2020/01/fundamentals-deep-learning-activation-functions-when-to-use-them/